考试系统；用户注册

这节正式进入开发，我们先来开发注册功能。

在 docker desktop 里把 mysql 的容器跑起来：

安装 prisma

npm install prisma --save-dev

然后执行 prisma init 创建 schema 文件：

npx prisma init

改下 .env 的配置：

DATABASE_URL="mysql://root:你的密码@localhost:3306/exam-system"

并且修改下 schema 里的 datasource 部分：

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

然后创建 model。

前面分析过用户表的结构：

字段名	数据类型	描述
id	INT	用户ID
username	VARCHAR(50)	用户名
password	VARCHAR(50)	密码
email	VARCHAR(50)	邮箱
create_time	DATETIME	创建时间
update_time	DATETIME	更新时间

创建对应的 modal：

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

model User {
  id  Int @id @default(autoincrement())
  username String @db.VarChar(50) @unique
  password String @db.VarChar(50)
  email String @db.VarChar(50)
  createTime DateTime @default(now())
  updateTime DateTime @updatedAt
}

这里 username 要添加唯一约束。

在 mysql workbench 里创建 exam-system 的数据库：

先 migrate reset，重置下数据库：

npx prisma migrate reset

然后创建新的 migration:

npx prisma migrate dev --name user

这时就生成了迁移文件，包含创建 user 表的 sql 语句：

在 mysql workbench 里可以看到创建好的 user 表：

并且 migrate dev 还会生成 client 代码，接下来我们就可以直接来做 CRUD 了。

创建个公共 lib

nest g lib prisma

改下 PrismaService，继承 PrismaClient，这样它就有 crud 的 api 了：

import { Injectable, OnModuleInit } from "@nestjs/common";
import { PrismaClient } from "@prisma/client";

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
    constructor() {
        super({
            log: [
                {
                    emit: "stdout",
                    level: "query",
                },
            ],
        });
    }

    async onModuleInit() {
        await this.$connect();
    }
}

在 constructor 里设置 PrismaClient 的 log 参数，也就是打印 sql 到控制台。

在 onModuleInit 的生命周期方法里调用 $connect 来连接数据库。

这样各处就都可以注入 PrismaService 用了。

在 user 微服务引入 PrismaModule：

然后在 UserService 里注入 PrismaService 来做 crud：

import { PrismaService } from "@app/prisma";
import { Inject, Injectable } from "@nestjs/common";
import { Prisma } from "@prisma/client";

@Injectable()
export class UserService {
    getHello(): string {
        return "Hello World!";
    }

    @Inject(PrismaService)
    private prisma: PrismaService;

    async create(data: Prisma.UserCreateInput) {
        return await this.prisma.user.create({
            data,
            select: {
                id: true,
            },
        });
    }
}

写代码的时候你会发现，参数的类型 prisma 都给你生成好了，直接用就行：

我们这节实现注册：

在 UserController 增加一个 post 接口：

import {
    Controller,
    Get,
    Post,
    Body,
    Patch,
    Param,
    Delete,
} from "@nestjs/common";
import { UserService } from "./user.service";
import { RegisterUserDto } from "./dto/register-user.dto";

@Controller("user")
export class UserController {
    constructor(private readonly userService: UserService) {}

    @Post("register")
    async register(@Body() registerUser: RegisterUserDto) {
        return await this.userService.create(registerUser);
    }
}

创建 dto/register-user.dto.ts

export class RegisterUserDto {
    username: string;

    password: string;

    email: string;

    captcha: string;
}

把服务跑起来：

npm run start:dev user

在 postman 里调用下试试：

{
    "username": "guang",
    "password": "123456",
    "email": "[email protected]",
    "captcha": "abc123"
}

报错了：

数据库中没有 captcha 的字段。

我们要在调用 service 之前删掉它：

再试一下：

服务端打印了 insert 的 sql 语句：

数据库里也可以看到这条记录：

然后加一下 ValidationPipe，来对请求体做校验。

安装用到的包：

npm install --save class-validator class-transformer

全局启用 ValidationPipe：

app.useGlobalPipes(new ValidationPipe());

然后加一下校验规则：

import { IsEmail, IsNotEmpty, MinLength } from "class-validator";

export class RegisterUserDto {
    @IsNotEmpty({
        message: "用户名不能为空",
    })
    username: string;

    @IsNotEmpty({
        message: "密码不能为空",
    })
    @MinLength(6, {
        message: "密码不能少于 6 位",
    })
    password: string;

    @IsNotEmpty({
        message: "邮箱不能为空",
    })
    @IsEmail(
        {},
        {
            message: "不是合法的邮箱格式",
        }
    )
    email: string;

    @IsNotEmpty({
        message: "验证码不能为空",
    })
    captcha: string;
}

测试下：

没啥问题。

然后实现注册的逻辑。

注册的逻辑是这样的：

继续实现 UserService 的 register 方法：

import {
    HttpException,
    HttpStatus,
    Inject,
    Injectable,
    Logger,
} from "@nestjs/common";
import { PrismaService } from "@app/prisma";
import { RedisService } from "@app/redis";
import { RegisterUserDto } from "./dto/register-user.dto";

@Injectable()
export class UserService {
    @Inject(PrismaService)
    private prismaService: PrismaService;

    @Inject(RedisService)
    private redisService: RedisService;

    private logger = new Logger();

    async register(user: RegisterUserDto) {
        const captcha = await this.redisService.get(`captcha_${user.email}`);

        if (!captcha) {
            throw new HttpException("验证码已失效", HttpStatus.BAD_REQUEST);
        }

        if (user.captcha !== captcha) {
            throw new HttpException("验证码不正确", HttpStatus.BAD_REQUEST);
        }

        const foundUser = await this.prismaService.user.findUnique({
            where: {
                username: user.username,
            },
        });

        if (foundUser) {
            throw new HttpException("用户已存在", HttpStatus.BAD_REQUEST);
        }

        try {
            return await this.prismaService.user.create({
                data: {
                    username: user.username,
                    password: user.password,
                    email: user.email,
                },
                select: {
                    id: true,
                    username: true,
                    email: true,
                    createTime: true,
                },
            });
        } catch (e) {
            this.logger.error(e, UserService);
            return null;
        }
    }
}

先检查验证码是否正确，如果正确的话，检查用户是否存在，然后用 prismaService.create 插入数据。

失败的话用 Logger 记录错误日志。

这里的 md5 方法放在 src/utils.ts 里，用 node 内置的 crypto 包实现。

import * as crypto from "crypto";

export function md5(str) {
    const hash = crypto.createHash("md5");
    hash.update(str);
    return hash.digest("hex");
}

在 UserController 里调用下：

import {
    Controller,
    Get,
    Post,
    Body,
    Patch,
    Param,
    Delete,
} from "@nestjs/common";
import { UserService } from "./user.service";
import { RegisterUserDto } from "./dto/register-user.dto";

@Controller("user")
export class UserController {
    constructor(private readonly userService: UserService) {}

    @Post("register")
    async register(@Body() registerUser: RegisterUserDto) {
        return await this.userService.register(registerUser);
    }
}

然后在 postman 里测试下：

因为还没实现发送邮箱验证码的逻辑，这里我们手动在 redis 添加一个 key：

测试下：

带上错误的验证码，返回验证码不正确；

带上正确的验证码，注册成功：

这时可以在数据库里看到这条记录：

然后我们来实现发送邮箱验证码的功能。

封装个 email 的 lib：

nest g lib email

安装发送邮件用的包：

npm install nodemailer --save

在 EmailService 里实现 sendMail 方法

import { Injectable } from "@nestjs/common";
import { createTransport, Transporter } from "nodemailer";

@Injectable()
export class EmailService {
    transporter: Transporter;

    constructor() {
        this.transporter = createTransport({
            host: "smtp.qq.com",
            port: 587,
            secure: false,
            auth: {
                user: "你的邮箱地址",
                pass: "你的授权码",
            },
        });
    }

    async sendMail({ to, subject, html }) {
        await this.transporter.sendMail({
            from: {
                name: "考试系统",
                address: "你的邮箱地址",
            },
            to,
            subject,
            html,
        });
    }
}

把邮箱地址和授权码改成你自己的。

具体怎么生成授权码，看前面的 node 发送邮件那节。

引入 EmailModule：

然后在 UserController 里添加一个 get 接口：

import {
    Controller,
    Get,
    Post,
    Body,
    Patch,
    Param,
    Delete,
    Inject,
    Query,
} from "@nestjs/common";
import { UserService } from "./user.service";
import { RegisterUserDto } from "./dto/register-user.dto";
import { EmailService } from "@app/email";
import { RedisService } from "@app/redis";

@Controller("user")
export class UserController {
    constructor(private readonly userService: UserService) {}

    @Inject(EmailService)
    private emailService: EmailService;

    @Inject(RedisService)
    private redisService: RedisService;

    @Get("register-captcha")
    async captcha(@Query("address") address: string) {
        const code = Math.random().toString().slice(2, 8);

        await this.redisService.set(`captcha_${address}`, code, 5 * 60);

        await this.emailService.sendMail({
            to: address,
            subject: "注册验证码",
            html: `<p>你的注册验证码是 ${code}</p>`,
        });
        return "发送成功";
    }

    @Post("register")
    async register(@Body() registerUser: RegisterUserDto) {
        return await this.userService.register(registerUser);
    }
}